home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / iutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  9.3 KB  |  474 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  iutil.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*      iutil.c         RD, 22.12.89    */
  17. /*    Added functions cIasuint, cIaslong, cIasulong,
  18.         Iisint, Iisuint, Iislong, Iisulong,
  19.         intasI, uintasI, longasI, ulongasI, RD, 16.12.91
  20.     Put definition of INTTOPLACE into iutil.c, RD, 16.12.91
  21. */
  22.  
  23. #include <LEDA/impl/iint.h>
  24. #include <LEDA/impl/iloc.h>
  25. #include <stdio.h>
  26.  
  27. #define INTTOPLACE  ((sizeof(int)+sizeof(PLACE)-1)/sizeof(PLACE))
  28. #define LONGTOPLACE ((sizeof(long)+sizeof(PLACE)-1)/sizeof(PLACE))
  29.  
  30. void cI(a)
  31.         register Integer * a;
  32. {       a->sign=PLUS;
  33.         a->length=0;
  34.         a->maxlength=INITLENGTH;
  35.         a->vec=newvec(&a->maxlength);
  36. }       /* cI */
  37.  
  38. void cIasint(a, i)
  39.         register Integer * a; register int i;
  40. {       register int j;
  41.         if (i<0) {
  42.                 a->sign=MINUS;
  43.                 i=-i;
  44.         } else 
  45.                 a->sign=PLUS;
  46.         a->maxlength=INTTOPLACE;
  47.         a->vec=newvec(&a->maxlength);
  48.     if ( INTTOPLACE == 1 ) {
  49.         a->vec[0]=i;
  50.         if ( i )
  51.             a->length=1;
  52.         else
  53.             a->length=0;
  54.         return;
  55.     }
  56.         j=0;
  57.         while (i) {
  58.                 a->vec[j]=i;
  59.                 i>>=LOGPLACE;
  60.         j++;
  61.         }
  62.     a->length=j;
  63. }               /* cIasint */
  64.  
  65. void cIasuint(a, i)
  66.         register Integer * a; register unsigned int i;
  67. {       register int j;
  68.         a->sign=PLUS;
  69.         a->maxlength=INTTOPLACE;
  70.         a->vec=newvec(&a->maxlength);
  71.     if ( INTTOPLACE == 1 ) {
  72.         a->vec[0]=i;
  73.         if ( i )
  74.             a->length=1;
  75.         else
  76.             a->length=0;
  77.         return;
  78.     }
  79.         j=0;
  80.         while (i) {
  81.                 a->vec[j]=i;
  82.                 i>>=LOGPLACE;
  83.         j++;
  84.         }
  85.     a->length=j;
  86. }               /* cIasuint */
  87.  
  88. void cIaslong(a, i)
  89.         register Integer * a; register long i;
  90. {       register int j;
  91.         if (i<0) {
  92.                 a->sign=MINUS;
  93.                 i=-i;
  94.         } else 
  95.                 a->sign=PLUS;
  96.         a->maxlength=LONGTOPLACE;
  97.         a->vec=newvec(&a->maxlength);
  98.     if ( LONGTOPLACE == 1 ) {
  99.         a->vec[0]=i;
  100.         if ( i )
  101.             a->length=1;
  102.         else
  103.             a->length=0;
  104.         return;
  105.     }
  106.         j=0;
  107.         while (i) {
  108.                 a->vec[j]=i;
  109.                 i>>=LOGPLACE;
  110.         j++;
  111.         }
  112.     a->length=j;
  113. }               /* cIaslong */
  114.  
  115. void cIasulong(a, i)
  116.         register Integer * a; register unsigned long i;
  117. {       register int j;
  118.         a->sign=PLUS;
  119.         a->maxlength=LONGTOPLACE;
  120.         a->vec=newvec(&a->maxlength);
  121.     if ( LONGTOPLACE == 1 ) {
  122.         a->vec[0]=i;
  123.         if ( i )
  124.             a->length=1;
  125.         else
  126.             a->length=0;
  127.         return;
  128.     }
  129.         j=0;
  130.         while (i) {
  131.                 a->vec[j]=i;
  132.                 i>>=LOGPLACE;
  133.         j++;
  134.         }
  135.     a->length=j;
  136. }               /* cIasulong */
  137.  
  138. void cIasI(a, b)
  139. /* create a from b */
  140.         register Integer *a;
  141.     register const Integer *b;
  142. {       register int i;
  143.         a->sign=b->sign;
  144.         a->length=b->length;
  145.         a->maxlength=b->length;
  146.         a->vec=newvec(&a->maxlength);
  147.         for (i=0; i<b->length; i++)
  148.                 a->vec[i]=b->vec[i];
  149. }               /* cIasI */
  150.  
  151. void cImaxlength(a, l)
  152.         register Integer * a;
  153.     int l;
  154. {       a->sign=PLUS;
  155.         a->length=0;
  156.         a->maxlength=l;
  157.         a->vec=newvec(&a->maxlength);
  158. }       /* cI */
  159.  
  160. void dI(a)
  161.         register Integer * a;
  162. {       delvec(a->vec, a->maxlength);
  163.         a->vec=NULL;
  164. }
  165.  
  166. Integer *  ncI()
  167. {    register Integer *a;
  168.     a=newInteger();
  169.     cI(a);
  170.     return a;
  171. }
  172.  
  173. Integer *  ncIasint(i)
  174.     int i;
  175. {    register Integer *a;
  176.     a=newInteger();
  177.     cIasint(a, i);
  178.     return a;
  179. }
  180.  
  181. Integer *  ncIasI(b)
  182.     Integer *b;
  183. {    register Integer *a;
  184.     a=newInteger();
  185.     cIasI(a, b);
  186.     return a;
  187. }
  188.  
  189. Integer *  ncImaxlength(l)
  190.     int l;
  191. {    register Integer *a;
  192.     a=newInteger();
  193.     cImaxlength(a, l);
  194.     return a;
  195. }
  196.  
  197. void ddI(a)
  198.     Integer *a;
  199. {    dI(a);
  200.     delInteger(a);
  201. }
  202.  
  203. /************************************/
  204.  
  205. void IasI(a, b)
  206.         register Integer *a;
  207.     register const Integer *b;
  208. {       register int i;
  209.         register int neededlength;
  210.     a->sign=b->sign;
  211.     neededlength=b->length;
  212.     if (a->maxlength < neededlength) {
  213.         delvec(a->vec, a->maxlength);
  214.         a->maxlength=neededlength;
  215.         a->vec=newvec(&a->maxlength);
  216.     }
  217.         a->length=neededlength;
  218.         for (i=b->length-1; i>=0; i--)
  219.                 a->vec[i]=b->vec[i];
  220. }               /* IasI */
  221.  
  222. void Iasint(a, i)
  223.     register Integer * a; register int i;
  224. {       register int j;
  225.         if (i<0) {
  226.                 a->sign=MINUS;
  227.                 i=-i;
  228.         } else 
  229.                 a->sign=PLUS;
  230.     if ( INTTOPLACE == 1 ) {
  231.         a->vec[0]=i;
  232.         if ( i )
  233.             a->length=1;
  234.         else
  235.             a->length=0;
  236.         return;
  237.     }
  238.         j=0;
  239.         while (i) {
  240.                 a->vec[j]=i;
  241.                 i>>=LOGPLACE;
  242.         j++;
  243.         }
  244.     a->length=j;
  245. }               /* Iasint */
  246.  
  247. void Ias0(a)
  248.     register Integer * a;
  249. {    a->length=0;
  250.     a->sign=PLUS;
  251. }
  252.  
  253. void Ias1(a)
  254.     register Integer * a;
  255. {    a->length=1;
  256.     a->sign=PLUS;
  257.     *(a->vec)=1;
  258. }
  259.  
  260. /************************************/
  261.  
  262. int Ilog(a)
  263.     const Integer * a;
  264. /* return (groesste Ganze von log_2(|a|), bzw -1 falls a==0); */
  265. {    register PLACE m;
  266.     register int i, j;
  267.  
  268.     i=a->length;
  269.     if (!i)
  270.         return -1;
  271.     j=0;
  272.     m=a->vec[i-1];
  273.     m>>=1;
  274.     while(m) {
  275.         m>>=1;
  276.         j++;
  277.     }
  278.     return j+(i-1)*LOGPLACE;
  279. }
  280.  
  281. int intlog(i)
  282.     register int i;
  283. /* return (groesste Ganze von log_2(|i|), bzw -1 falls a==0); */
  284. {    register int j;
  285.  
  286.     if (!i)
  287.         return -1;
  288.     j=0;
  289.     i>>=1;
  290.     while(i) {
  291.         i>>=1;
  292.         j++;
  293.     }
  294.     return j;
  295. }    /* intlog */
  296.  
  297. void Ierror(s)
  298.     const char * s;
  299. {    fprintf(stderr, "I: %s\n", s);
  300.     exit(-1);
  301. }        /* Ierror */
  302.  
  303. /******************************************************************/
  304.  
  305. static unsigned long maxint=(1<<sizeof(int)*8-1)-1;
  306. static unsigned long maxnegint=(1<<sizeof(int)*8-1);
  307. static unsigned long maxuint=1<<sizeof(int)*8;
  308. static unsigned long maxlong=(1<<sizeof(long)*8-1)-1;
  309. static unsigned long maxneglong=(1<<sizeof(long)*8-1);
  310.  
  311. BOOLEAN Iisint (a)
  312.     const Integer * a;
  313. {    register unsigned int u;
  314.     register int i;
  315.     if (!a->length)
  316.         return TRUE;
  317.     if (a->length>INTTOPLACE)
  318.         return FALSE;
  319. /* Maybe sizeof(int)<sizeof(PLACE), then INTTOPLACE==1 */
  320. /* We assume that sizeof(long)>=sizeof(PLACE) */
  321.     if (sizeof(int)<sizeof(PLACE))
  322.         if (a->sign==PLUS)
  323.             return a->vec[0] <= maxint;
  324.         else
  325.             return a->vec[0] <= maxnegint;
  326. /* Now we assume that sizeof(PLACE) divides sizeof(int) ! */
  327.     u=0;
  328.     for (i=a->length-1; i>=0; i--) {
  329.         u<<=LOGPLACE;
  330.         u+=a->vec[i];
  331.     }
  332.     if (a->sign==PLUS)
  333.         return u <= maxint;
  334.     else
  335.         return u <= maxnegint;
  336. }    /* Iisint */
  337.  
  338. BOOLEAN Iisuint (a)
  339.     const Integer * a;
  340. {    if (a->sign==MINUS)
  341.         return FALSE;
  342.     if (!a->length)
  343.         return TRUE;
  344.     if (a->length>INTTOPLACE)
  345.         return FALSE;
  346. /* Maybe sizeof(int)<sizeof(PLACE), then INTTOPLACE==1 */
  347. /* We assume, that sizeof(long)>=sizeof(PLACE) */
  348.     if (sizeof(int)<sizeof(PLACE))
  349.         return a->vec[0] <= maxuint;
  350. /* Now we assume, that sizeof(PLACE) divides sizeof(int) ! */
  351.     return TRUE;
  352. }    /* Iisuint */
  353.  
  354. BOOLEAN Iislong (a)
  355.     const Integer * a;
  356. {
  357. /* We assume that sizeof(long)>=sizeof(PLACE) and
  358.    that sizeof(PLACE) divides sizeof(long) ! */
  359.     register unsigned long u;
  360.     register int i;
  361.     if (!a->length)
  362.         return TRUE;
  363.     if (a->length>LONGTOPLACE)
  364.         return FALSE;
  365.     u=0;
  366.     for (i=a->length-1; i>=0; i--) {
  367.         u<<=LOGPLACE;
  368.         u+=a->vec[i];
  369.     }
  370.     if (a->sign==PLUS)
  371.         return u <= maxlong;
  372.     else
  373.         return u <= maxneglong;
  374. }    /* Iislong */
  375.  
  376. BOOLEAN Iisulong (a)
  377.     const Integer * a;
  378. {    if (a->sign==MINUS)
  379.         return FALSE;
  380. /* We assume, that sizeof(PLACE) divides sizeof(long) ! */
  381.     if (a->length<=LONGTOPLACE)
  382.         return TRUE;
  383.     else
  384.         return FALSE;
  385. }    /* Iisulong */
  386.  
  387.  
  388. int intasI (a)
  389.     const Integer * a;
  390. /* We assume Iisint(a) to be true ! */
  391. {    register unsigned int u;
  392.     register int i;
  393.     if (!a->length)
  394.         return 0;
  395. /* Maybe sizeof(int)<sizeof(PLACE), then INTTOPLACE==1 */
  396. /* We assume that sizeof(long)>=sizeof(PLACE) */
  397.     if (sizeof(int)<sizeof(PLACE))
  398.         if (a->sign==PLUS)
  399.             return a->vec[0];
  400.         else
  401.             return - a->vec[0];
  402. /* Now we assume that sizeof(PLACE) divides sizeof(int) ! */
  403.     u=0;
  404.     for (i=a->length-1; i>=0; i--) {
  405.         u<<=LOGPLACE;
  406.         u+=a->vec[i];
  407.     }
  408.     if (a->sign==PLUS)
  409.         return u;
  410.     else
  411.         return -u;
  412. }    /* intasI */
  413.  
  414. unsigned int uintasI (a)
  415.     const Integer * a;
  416. /* We assume Iisuint(a) to be true ! */
  417. {    register unsigned int u;
  418.     register int i;
  419.     if (!a->length)
  420.         return 0;
  421. /* Maybe sizeof(int)<sizeof(PLACE), then INTTOPLACE==1 */
  422. /* We assume that sizeof(long)>=sizeof(PLACE) */
  423.     if (sizeof(int)<sizeof(PLACE))
  424.         return a->vec[0];
  425. /* Now we assume that sizeof(PLACE) divides sizeof(int) ! */
  426.     u=0;
  427.     for (i=a->length-1; i>=0; i--) {
  428.         u<<=LOGPLACE;
  429.         u+=a->vec[i];
  430.     }
  431.     return u;
  432. }    /* uintasI */
  433.  
  434. long longasI (a)
  435.     const Integer * a;
  436. /* We assume Iislong(a) to be true ! */
  437. {
  438. /* We assume that sizeof(long)>=sizeof(PLACE) and
  439.    that sizeof(PLACE) divides sizeof(long) ! */
  440.     register unsigned long u;
  441.     register int i;
  442.     if (!a->length)
  443.         return 0;
  444.     u=0;
  445.     for (i=a->length-1; i>=0; i--) {
  446.         u<<=LOGPLACE;
  447.         u+=a->vec[i];
  448.     }
  449.     if (a->sign==PLUS)
  450.         return u;
  451.     else
  452.         return -u;
  453. }    /* longasI */
  454.  
  455. unsigned long ulongasI (a)
  456.     const Integer * a;
  457. /* We assume Iisulong(a) to be true ! */
  458. {
  459. /* We assume, that sizeof(PLACE) divides sizeof(long) ! */
  460.     register unsigned long u;
  461.     register int i;
  462.     if (!a->length)
  463.         return 0;
  464.     u=0;
  465.     for (i=a->length-1; i>=0; i--) {
  466.         u<<=LOGPLACE;
  467.         u+=a->vec[i];
  468.     }
  469.     return u;
  470. }    /* ulongasI */
  471.  
  472.  
  473.  
  474.